# time_sync.py
import configparser
import os
import logging
from datetime import datetime, timedelta
import requests
import pytz  # 添加时区支持

# 初始化日志器
logger = logging.getLogger("EMS_TimeSync")
if not logger.handlers:
    handler = logging.StreamHandler()
    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)
    logger.propagate = False

class NetherlandsTimeSync:
    """荷兰时间同步器 - 算法动态计算荷兰时间，自动处理夏令时/冬令时切换"""
    
    def __init__(self):
        # 读取配置文件
        config = configparser.ConfigParser()
        config_path = os.path.join(os.path.dirname(__file__), 'config.ini')
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config.read_file(f)
        except Exception as e:
            logger.error(f"[配置文件] 读取失败: {e}")
            config = None

        self.time_offset = None  # 偏移量（秒）
        self.use_api = config.getboolean('time', 'enable_api_time_sync', fallback=False) if config else False
        self.offset_hours = config.getfloat('time', 'netherlands_offset_hours', fallback=-6.0) if config else -6.0
        
        # 荷兰时区信息
        self.netherlands_tz = pytz.timezone('Europe/Amsterdam')
        # 本地时区（假设为系统时区）
        self.local_tz = pytz.timezone('Asia/Shanghai')  # 可根据实际情况调整
        
    def _calculate_netherlands_time_algorithm(self) -> float:
        """算法动态计算荷兰时间偏移量，自动处理夏令时/冬令时切换"""
        try:
            # 获取当前UTC时间
            utc_now = datetime.utcnow()
            
            # 将UTC时间转换为荷兰时区时间
            utc_dt = pytz.utc.localize(utc_now)
            netherlands_dt = utc_dt.astimezone(self.netherlands_tz)
            
            # 将UTC时间转换为本地时区时间
            local_dt = utc_dt.astimezone(self.local_tz)
            
            # 计算荷兰时间和本地时间相对于UTC的偏移量差值
            netherlands_offset = netherlands_dt.utcoffset().total_seconds()
            local_offset = local_dt.utcoffset().total_seconds()
            
            # 计算时差：荷兰时间偏移量 - 本地时间偏移量
            offset_seconds = netherlands_offset - local_offset
            
            # 获取当前时区信息
            is_dst = netherlands_dt.dst().total_seconds() > 0
            timezone_name = netherlands_dt.tzname()
            
            logger.info(f"[算法计算] 荷兰时间: {netherlands_dt.strftime('%Y-%m-%d %H:%M:%S')} ({timezone_name})")
            logger.info(f"[算法计算] 本地时间: {local_dt.strftime('%Y-%m-%d %H:%M:%S')}")
            logger.info(f"[算法计算] 动态偏移量: {offset_seconds/3600:.1f}小时 (夏令时: {'是' if is_dst else '否'})")
            
            return offset_seconds
            
        except Exception as e:
            logger.warning(f"[算法计算] 算法计算失败: {e}")
            return None
    
    def sync_time_once(self) -> bool:
        """同步时间 - 三级容错机制：API → 算法 → 固定配置"""
        try:
            if not self.use_api:
                # 直接使用算法计算
                algorithm_offset = self._calculate_netherlands_time_algorithm()
                if algorithm_offset is not None:
                    self.time_offset = algorithm_offset
                    logger.info(f"[时间同步] 使用算法计算偏移量: {self.time_offset/3600:.1f}小时")
                    return True
                else:
                    # 算法失败，使用固定配置
                    self.time_offset = self.offset_hours * 3600
                    logger.info(f"[时间同步] 算法失败，使用固定偏移值: {self.offset_hours}小时")
                    return False
                
            # 第一级：API方式
            logger.info("[时间同步] 尝试API获取荷兰时间...")
            response = requests.get("https://worldtimeapi.org/api/timezone/Europe/Amsterdam", timeout=5)
            response.raise_for_status()
            
            data = response.json()
            netherlands_datetime_str = data["datetime"]
            netherlands_dt = datetime.fromisoformat(netherlands_datetime_str)
            netherlands_naive = netherlands_dt.replace(tzinfo=None)
            
            local_now = datetime.now()
            self.time_offset = (netherlands_naive - local_now).total_seconds()
            
            logger.info(f"[时间同步] API获取成功，偏移量: {self.time_offset/3600:.1f}小时")
            return True
            
        except Exception as e:
            # 第二级：API失败，尝试算法计算
            logger.warning(f"[时间同步] API失败，尝试算法计算: {e}")
            algorithm_offset = self._calculate_netherlands_time_algorithm()
            
            if algorithm_offset is not None:
                self.time_offset = algorithm_offset
                logger.info(f"[时间同步] 算法计算成功，偏移量: {self.time_offset/3600:.1f}小时")
                return True
            else:
                # 第三级：算法也失败，使用固定配置
                logger.warning("[时间同步] 算法计算失败，使用固定配置偏移值")
                self.time_offset = self.offset_hours * 3600
                logger.info(f"[时间同步] 使用固定偏移值: {self.offset_hours}小时")
                return False
    
    def get_netherlands_time(self) -> datetime:
        """获取当前荷兰时间"""
        if self.time_offset is None:
            self.sync_time_once()
        
        # 基于配置文件的偏移量计算荷兰时间
        local_now = datetime.now()
        netherlands_now = local_now + timedelta(seconds=self.time_offset or 0)
        
        # 添加调试打印，验证时间计算
        print(f"[时间调试] 本地时间: {local_now.strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"[时间调试] 偏移值: {self.time_offset/3600:.1f}小时")
        print(f"[时间调试] 荷兰时间: {netherlands_now.strftime('%Y-%m-%d %H:%M:%S')}")
        
        return netherlands_now

# 创建荷兰时间同步器实例
netherlands_time = NetherlandsTimeSync()

# 启动时同步时间
netherlands_time.sync_time_once()